package com.xuan.utils.xuan.bazi;

import com.nlf.calendar.Lunar;
import com.nlf.calendar.Solar;
import com.xuan.configuration.exception.SystemException;
import com.xuan.configuration.result.ResponseResultEnum;
import com.xuan.dto.pg.bazi.GanZhiGuanXiOption;
import org.apache.commons.lang3.StringUtils;

import java.util.*;

/**
 * 八字-基础工具
 *
 * @author 善待
 */
public class BaZiUtil {

    /**
     * 判断日期类型设置，返回公历日期、农历日期
     *
     * @param setting 八字-设置
     * @return 公历日期、农历日期
     */
    public static Map<String, Object> isDateType(BaZiSetting setting) {

        // 1、获取设置
        Date date = setting.getDate(); // 日期
        int dateType = setting.getDateType(); // 日期类型

        // 2、初始化日期
        Solar solar = new Solar(); // 公历日期
        Lunar lunar = new Lunar(); // 农历日期

        // 3、按公历日期计算
        if (dateType == 0) {
            // 3.1、通过日期初始化
            solar = new Solar(date); // 公历日期
            lunar = solar.getLunar(); // 农历日期
        }

        // 4、按农历日期计算
        if (dateType == 1) {
            // 4.1、通过日期获取年月日时分秒
            Calendar c = Calendar.getInstance();
            c.setTime(date);
            int year = c.get(Calendar.YEAR); // 年
            // 4.2、判断是否按闰月计算
            int month = setting.getIsLeapMonth() ? -(c.get(Calendar.MONTH) + 1) : c.get(Calendar.MONTH) + 1; // 月
            int day = c.get(Calendar.DATE); // 日
            int hour = c.get(Calendar.HOUR_OF_DAY); // 时
            int minute = c.get(Calendar.MINUTE); // 分
            int second = c.get(Calendar.SECOND); // 秒
            // 4.3、通过农历年月日时初始化
            try {
                lunar = new Lunar(year, month, day, hour, minute, second); // 农历日期
                solar = lunar.getSolar(); // 公历日期
            } catch (IllegalArgumentException e) {
//                throw new SystemException(ResponseResultEnum.LUNAR_LEAP_MONTH_ERROR); // 该农历日期无法使用闰月
                throw new SystemException(ResponseResultEnum.LUNAR_ERROR_1); // 该农历日期有误，无法排盘
            }
        }

        // 5、添加公历日期、农历日期并返回
        Map<String, Object> map = new HashMap<>();
        map.put("solar", solar); // 公历日期
        map.put("lunar", lunar); // 农历日期
        return map;

    }

    /**
     * 判断干支设置，返回干支
     *
     * @param setting 八字-设置
     * @param lunar   农历日期
     * @return 干支
     */
    public static Map<String, List<String>> isGanZhi(BaZiSetting setting, Lunar lunar) {

        // 1、获取设置
        int yearGanZhiSet = setting.getYearGanZhiSet(); // 年干支设置
        int monthGanZhiSet = setting.getMonthGanZhiSet(); // 月干支设置
        int dayGanZhiSet = setting.getDayGanZhiSet(); // 日干支设置

        List<String> list = new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();

        // 2、判断年干支设置并添加
        if (yearGanZhiSet == 0) {
            // 2.1、以正月初一作为新年的开始
            list = Arrays.asList(lunar.getYearGan(), lunar.getYearZhi(), lunar.getYearInGanZhi());
        } else if (yearGanZhiSet == 1) {
            // 2.2、以立春当天作为新年的开始
            list = Arrays.asList(lunar.getYearGanByLiChun(), lunar.getYearZhiByLiChun(), lunar.getYearInGanZhiByLiChun());
        } else if (yearGanZhiSet == 2) {
            // 2.3、以立春交接的时刻作为新年的开始
            list = Arrays.asList(lunar.getYearGanExact(), lunar.getYearZhiExact(), lunar.getYearInGanZhiExact());
        }
        map.put("yearGanZhi", list);

        // 3、判断月干支设置并添加
        if (monthGanZhiSet == 0) {
            // 3.1、以节交接当天起算
            list = Arrays.asList(lunar.getMonthGan(), lunar.getMonthZhi(), lunar.getMonthInGanZhi());
        } else if (monthGanZhiSet == 1) {
            // 3.2、以节交接时刻起算
            list = Arrays.asList(lunar.getMonthGanExact(), lunar.getMonthZhiExact(), lunar.getMonthInGanZhiExact());
        }
        map.put("monthGanZhi", list);

        // 4、判断日干支设置并添加
        if (dayGanZhiSet == 0) {
            // 4.1、晚子时日干支算当天
            list = Arrays.asList(lunar.getDayGanExact2(), lunar.getDayZhiExact2(), lunar.getDayInGanZhiExact2());
        } else if (dayGanZhiSet == 1) {
            // 4.2、晚子时日干支算明天
            list = Arrays.asList(lunar.getDayGanExact(), lunar.getDayZhiExact(), lunar.getDayInGanZhiExact());
        }
        map.put("dayGanZhi", list);

        // 5、时干支
        list = Arrays.asList(lunar.getTimeGan(), lunar.getTimeZhi(), lunar.getTimeInGanZhi());
        map.put("hourGanZhi", list);

        // 5、返回干支
        return map;

    }

    /**
     * 计算天干留意
     *
     * @param option        干支关系显示选项数据中间类
     * @param yearGanZhi    年干支（必须传入干支、数据长度不小于1，否则结果不完整）
     * @param monthGanZhi   月干支（必须传入干支、数据长度不小于1，否则结果不完整）
     * @param dayGanZhi     日干支（必须传入干支、数据长度不小于1，否则结果不完整）
     * @param hourGanZhi    时干支（必须传入干支、数据长度不小于1，否则结果不完整）
     * @param daYunGanZhi   大运干支（非必须传入，若为空则不计算）
     * @param liuNianGanZhi 流年干支（非必须传入，若为空则不计算）
     * @param liuYueGanZhi  流月干支（非必须传入，若为空则不计算）
     * @param liuRiGanZhi   流日干支（非必须传入，若为空则不计算）
     * @param liuShiGanZhi  流时干支（非必须传入，若为空则不计算）
     */
    public static List<String> tgLy(GanZhiGuanXiOption option, String yearGanZhi, String monthGanZhi, String dayGanZhi, String hourGanZhi, String daYunGanZhi, String liuNianGanZhi, String liuYueGanZhi, String liuRiGanZhi, String liuShiGanZhi) {

        String yg = "";  // 年干
        String mg = "";  // 月干
        String dg = "";  // 日干
        String hg = "";  // 时干
        String dyG = ""; // 大运干
        String lnG = ""; // 流年干
        String lyG = ""; // 流月干
        String lrG = ""; // 流日干
        String lsG = ""; // 流时干
        if (StringUtils.isNotBlank(yearGanZhi) && yearGanZhi.length() >= 1) yg = yearGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(monthGanZhi) && monthGanZhi.length() >= 1) mg = monthGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(dayGanZhi) && dayGanZhi.length() >= 1) dg = dayGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(hourGanZhi) && hourGanZhi.length() >= 1) hg = hourGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(daYunGanZhi) && daYunGanZhi.length() >= 1) dyG = daYunGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(liuNianGanZhi) && liuNianGanZhi.length() >= 1) lnG = liuNianGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(liuYueGanZhi) && liuYueGanZhi.length() >= 1) lyG = liuYueGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(liuRiGanZhi) && liuRiGanZhi.length() >= 1) lrG = liuRiGanZhi.substring(0, 1);
        if (StringUtils.isNotBlank(liuShiGanZhi) && liuShiGanZhi.length() >= 1) lsG = liuShiGanZhi.substring(0, 1);

        Set<String> set = new HashSet<>();

        // 添加天干留意
        if (option.getTianGanXiangShengSet()) addTgLy(yg, mg, dg, hg, dyG, lnG, lyG, lrG, lsG, set, BaZiMap.TIAN_GAN_XIANG_SHENG); // 天干相生
        if (option.getTianGanXiangHeSet()) addTgLy(yg, mg, dg, hg, dyG, lnG, lyG, lrG, lsG, set, BaZiMap.TIAN_GAN_XIANG_HE);       // 天干相合
        if (option.getTianGanXiangChongSet()) addTgLy(yg, mg, dg, hg, dyG, lnG, lyG, lrG, lsG, set, BaZiMap.TIAN_GAN_XIANG_CHONG); // 天干相冲
        if (option.getTianGanXiangKeSet()) addTgLy(yg, mg, dg, hg, dyG, lnG, lyG, lrG, lsG, set, BaZiMap.TIAN_GAN_XIANG_KE);       // 天干相克

        // 删除所有null并返回结果
        set.removeIf(Objects::isNull);
        return new ArrayList<>(set);

    }

    /**
     * 计算地支留意
     *
     * @param option        干支关系显示选项数据中间类
     * @param yearGanZhi    年干支（必须传入干支、数据长度不小于2，否则结果不完整）
     * @param monthGanZhi   月干支（必须传入干支、数据长度不小于2，否则结果不完整）
     * @param dayGanZhi     日干支（必须传入干支、数据长度不小于2，否则结果不完整）
     * @param hourGanZhi    时干支（必须传入干支、数据长度不小于2，否则结果不完整）
     * @param daYunGanZhi   大运干支（非必须传入干支，若为空则不计算）
     * @param liuNianGanZhi 流年干支（非必须传入干支，若为空则不计算）
     * @param liuYueGanZhi  流月干支（非必须传入干支，若为空则不计算）
     * @param liuRiGanZhi   流日干支（非必须传入干支，若为空则不计算）
     * @param liuShiGanZhi  流时干支（非必须传入干支，若为空则不计算）
     */
    public static List<String> dzLy(GanZhiGuanXiOption option, String yearGanZhi, String monthGanZhi, String dayGanZhi, String hourGanZhi, String daYunGanZhi, String liuNianGanZhi, String liuYueGanZhi, String liuRiGanZhi, String liuShiGanZhi) {

        String yz = "";  // 年支
        String mz = "";  // 月支
        String dz = "";  // 日支
        String hz = "";  // 时支
        String dyZ = ""; // 大运支
        String lnZ = ""; // 流年支
        String lyZ = ""; // 流月支
        String lrZ = ""; // 流日支
        String lsZ = ""; // 流时支
        if (StringUtils.isNotBlank(yearGanZhi) && yearGanZhi.length() >= 2) yz = yearGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(monthGanZhi) && monthGanZhi.length() >= 2) mz = monthGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(dayGanZhi) && dayGanZhi.length() >= 2) dz = dayGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(hourGanZhi) && hourGanZhi.length() >= 2) hz = hourGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(daYunGanZhi) && daYunGanZhi.length() >= 2) dyZ = daYunGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(liuNianGanZhi) && liuNianGanZhi.length() >= 2) lnZ = liuNianGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(liuYueGanZhi) && liuYueGanZhi.length() >= 2) lyZ = liuYueGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(liuRiGanZhi) && liuRiGanZhi.length() >= 2) lrZ = liuRiGanZhi.substring(1, 2);
        if (StringUtils.isNotBlank(liuShiGanZhi) && liuShiGanZhi.length() >= 2) lsZ = liuShiGanZhi.substring(1, 2);

        Set<String> set = new HashSet<>();

        // 添加地支留意
        if (option.getDiZhiBanHeSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_BAN_HE);           // 地支半合
        if (option.getDiZhiGongHeSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_GONG_HE);         // 地支拱合
        if (option.getDiZhiAnHeSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_AN_HE);             // 地支暗合
        if (option.getDiZhiSanHeSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_SAN_HE);           // 地支三合
        if (option.getDiZhiLiuHeSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_LIU_HE);           // 地支六合
        if (option.getDiZhiXiangXingSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_XIANG_XING);   // 地支相刑
        if (option.getDiZhiSanXingSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_SAN_XING);       // 地支三刑
        if (option.getDiZhiXiangChongSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_XIANG_CHONG); // 地支相冲
        if (option.getDiZhiXiangPoSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_XIANG_PO);       // 地支相破
        if (option.getDiZhiXiangHaiSet()) addDzLy(yz, mz, dz, hz, dyZ, lnZ, lyZ, lrZ, lsZ, set, BaZiMap.DI_ZHI_XIANG_HAI);     // 地支相害

        // 删除所有null并返回结果
        set.removeIf(Objects::isNull);
        return new ArrayList<>(set);

    }

//----------------------------------------------------------------------------------------------------------------------------------------------------

    /**
     * 通用：添加天干留意
     *
     * @param yearGan    年干
     * @param monthGan   月干
     * @param dayGan     日干
     * @param hourGan    时干
     * @param daYunGan   大运干
     * @param liuNianGan 流年干
     * @param liuYueGan  流月干
     * @param liuRiGan   流日干
     * @param liuShiGan  流时干
     * @param set        天干组合
     * @param map        天干关系
     */
    private static void addTgLy(String yearGan, String monthGan, String dayGan, String hourGan, String daYunGan, String liuNianGan, String liuYueGan, String liuRiGan, String liuShiGan, Set<String> set, Map<String, String> map) {

        // 1、计算四柱天干留意
        set.add(map.get(yearGan + monthGan)); // 年干+月干
        set.add(map.get(yearGan + dayGan));   // 年干+日干
        set.add(map.get(yearGan + hourGan));  // 年干+时干
        set.add(map.get(monthGan + yearGan)); // 月干+年干
        set.add(map.get(monthGan + dayGan));  // 月干+日干
        set.add(map.get(monthGan + hourGan)); // 月干+时干
        set.add(map.get(dayGan + yearGan));   // 日干+年干
        set.add(map.get(dayGan + monthGan));  // 日干+月干
        set.add(map.get(dayGan + hourGan));   // 日干+时干
        set.add(map.get(hourGan + yearGan));  // 时干+年干
        set.add(map.get(hourGan + monthGan)); // 时干+月干
        set.add(map.get(hourGan + dayGan));   // 时干+日干

        // 2、大运天干与其他天干留意
        if (!"".equals(daYunGan)) {
            set.add(map.get(yearGan + daYunGan));  // 年干+大运天干
            set.add(map.get(monthGan + daYunGan)); // 月干+大运天干
            set.add(map.get(dayGan + daYunGan));   // 日干+大运天干
            set.add(map.get(hourGan + daYunGan));  // 时干+大运天干
            set.add(map.get(daYunGan + yearGan));  // 大运天干+年干
            set.add(map.get(daYunGan + monthGan)); // 大运天干+月干
            set.add(map.get(daYunGan + dayGan));   // 大运天干+日干
            set.add(map.get(daYunGan + hourGan));  // 大运天干+时干
        }

        // 3、流年天干与其他天干留意（大运天干必须传入，否则结果不完整）
        if (!"".equals(liuNianGan)) {
            set.add(map.get(yearGan + liuNianGan));  // 年干+流年天干
            set.add(map.get(monthGan + liuNianGan)); // 月干+流年天干
            set.add(map.get(dayGan + liuNianGan));   // 日干+流年天干
            set.add(map.get(hourGan + liuNianGan));  // 时干+流年天干
            set.add(map.get(liuNianGan + yearGan));  // 流年天干+年干
            set.add(map.get(liuNianGan + monthGan)); // 流年天干+月干
            set.add(map.get(liuNianGan + dayGan));   // 流年天干+日干
            set.add(map.get(liuNianGan + hourGan));  // 流年天干+时干
            set.add(map.get(liuNianGan + daYunGan)); // 流年天干+大运天干
            set.add(map.get(daYunGan + liuNianGan)); // 大运天干+流年天干
        }

        // 4、流月天干与其他天干留意（大运天干、流年天干必须传入，否则结果不完整）
        if (!"".equals(liuYueGan)) {
            set.add(map.get(yearGan + liuYueGan));    // 年干+流月天干
            set.add(map.get(monthGan + liuYueGan));   // 月干+流月天干
            set.add(map.get(dayGan + liuYueGan));     // 日干+流月天干
            set.add(map.get(hourGan + liuYueGan));    // 时干+流月天干
            set.add(map.get(liuYueGan + yearGan));    // 流月天干+年干
            set.add(map.get(liuYueGan + monthGan));   // 流月天干+月干
            set.add(map.get(liuYueGan + dayGan));     // 流月天干+日干
            set.add(map.get(liuYueGan + hourGan));    // 流月天干+时干
            set.add(map.get(liuYueGan + daYunGan));   // 流月天干+大运天干
            set.add(map.get(daYunGan + liuYueGan));   // 大运天干+流月天干
            set.add(map.get(liuYueGan + liuNianGan)); // 流月天干+流年天干
            set.add(map.get(liuNianGan + liuYueGan)); // 流年天干+流月天干
        }

        // 5、流日天干与其他天干留意（大运天干、流年天干、流月天干必须传入，否则结果不完整）
        if (!"".equals(liuRiGan)) {
            set.add(map.get(yearGan + liuRiGan));    // 年干+流日天干
            set.add(map.get(monthGan + liuRiGan));   // 月干+流日天干
            set.add(map.get(dayGan + liuRiGan));     // 日干+流日天干
            set.add(map.get(hourGan + liuRiGan));    // 时干+流日天干
            set.add(map.get(liuRiGan + yearGan));    // 流日天干+年干
            set.add(map.get(liuRiGan + monthGan));   // 流日天干+月干
            set.add(map.get(liuRiGan + dayGan));     // 流日天干+日干
            set.add(map.get(liuRiGan + hourGan));    // 流日天干+时干
            set.add(map.get(liuRiGan + daYunGan));   // 流日天干+大运天干
            set.add(map.get(daYunGan + liuRiGan));   // 大运天干+流日天干
            set.add(map.get(liuRiGan + liuNianGan)); // 流日天干+流年天干
            set.add(map.get(liuNianGan + liuRiGan)); // 流年天干+流日天干
            set.add(map.get(liuRiGan + liuYueGan));  // 流日天干+流月天干
            set.add(map.get(liuYueGan + liuRiGan));  // 流月天干+流日天干
        }

        // 6、流时天干与其他天干留意（大运天干、流年天干、流月天干、流日天干必须传入，否则结果不完整）
        if (!"".equals(liuShiGan)) {
            set.add(map.get(yearGan + liuShiGan));    // 年干+流时天干
            set.add(map.get(monthGan + liuShiGan));   // 月干+流时天干
            set.add(map.get(dayGan + liuShiGan));     // 日干+流时天干
            set.add(map.get(hourGan + liuShiGan));    // 时干+流时天干
            set.add(map.get(liuShiGan + yearGan));    // 流时天干+年干
            set.add(map.get(liuShiGan + monthGan));   // 流时天干+月干
            set.add(map.get(liuShiGan + dayGan));     // 流时天干+日干
            set.add(map.get(liuShiGan + hourGan));    // 流时天干+时干
            set.add(map.get(liuShiGan + daYunGan));   // 流时天干+大运天干
            set.add(map.get(daYunGan + liuShiGan));   // 大运天干+流时天干
            set.add(map.get(liuShiGan + liuNianGan)); // 流时天干+流年天干
            set.add(map.get(liuNianGan + liuShiGan)); // 流年天干+流时天干
            set.add(map.get(liuShiGan + liuYueGan));  // 流时天干+流月天干
            set.add(map.get(liuYueGan + liuShiGan));  // 流月天干+流时天干
            set.add(map.get(liuShiGan + liuRiGan));   // 流时天干+流日天干
            set.add(map.get(liuRiGan + liuShiGan));   // 流日天干+流时天干
        }

    }

    /**
     * 通用：添加地支留意
     *
     * @param yearZhi    年支
     * @param monthZhi   月支
     * @param dayZhi     日支
     * @param hourZhi    时支
     * @param daYunZhi   大运支
     * @param liuNianZhi 流年支
     * @param liuYueZhi  流月支
     * @param liuRiZhi   流日支
     * @param liuShiZhi  流时干支
     * @param set        地支组合
     * @param map        地支关系
     */
    private static void addDzLy(String yearZhi, String monthZhi, String dayZhi, String hourZhi, String daYunZhi, String liuNianZhi, String liuYueZhi, String liuRiZhi, String liuShiZhi, Set<String> set, Map<String, String> map) {

        // 1、计算四柱地支留意
        set.add(map.get(yearZhi + monthZhi));  // 年支+月支
        set.add(map.get(yearZhi + dayZhi));    // 年支+日支
        set.add(map.get(yearZhi + hourZhi));   // 年支+时支
        set.add(map.get(monthZhi + yearZhi));  // 月支+年支
        set.add(map.get(monthZhi + dayZhi));   // 月支+日支
        set.add(map.get(monthZhi + hourZhi));  // 月支+时支
        set.add(map.get(dayZhi + yearZhi));    // 日支+年支
        set.add(map.get(dayZhi + monthZhi));   // 日支+月支
        set.add(map.get(dayZhi + hourZhi));    // 日支+时支
        set.add(map.get(hourZhi + yearZhi));   // 时支+年支
        set.add(map.get(hourZhi + monthZhi));  // 时支+月支
        set.add(map.get(hourZhi + dayZhi));    // 时支+日支

        // 2、大运地支与其他地支留意
        if (!"".equals(daYunZhi)) {
            set.add(map.get(yearZhi + daYunZhi));   // 年支+大运地支
            set.add(map.get(monthZhi + daYunZhi));  // 月支+大运地支
            set.add(map.get(dayZhi + daYunZhi));    // 日支+大运地支
            set.add(map.get(hourZhi + daYunZhi));   // 时支+大运地支
            set.add(map.get(daYunZhi + yearZhi));   // 大运地支+年支
            set.add(map.get(daYunZhi + monthZhi));  // 大运地支+月支
            set.add(map.get(daYunZhi + dayZhi));    // 大运地支+日支
            set.add(map.get(daYunZhi + hourZhi));   // 大运地支+时支
        }

        // 3、流年地支与其他地支留意（大运地支必须传入，否则结果不完整）
        if (!"".equals(liuNianZhi)) {
            set.add(map.get(yearZhi + liuNianZhi));  // 年支+流年地支
            set.add(map.get(monthZhi + liuNianZhi)); // 月支+流年地支
            set.add(map.get(dayZhi + liuNianZhi));   // 日支+流年地支
            set.add(map.get(hourZhi + liuNianZhi));  // 时支+流年地支
            set.add(map.get(liuNianZhi + yearZhi));  // 流年地支+年支
            set.add(map.get(liuNianZhi + monthZhi)); // 流年地支+月支
            set.add(map.get(liuNianZhi + dayZhi));   // 流年地支+日支
            set.add(map.get(liuNianZhi + hourZhi));  // 流年地支+时支
            set.add(map.get(liuNianZhi + daYunZhi)); // 流年地支+大运地支
            set.add(map.get(daYunZhi + liuNianZhi)); // 大运地支+流年地支
        }

        // 4、流月地支与其他地支留意（大运地支、流年地支必须传入，否则结果不完整）
        if (!"".equals(liuYueZhi)) {
            set.add(map.get(yearZhi + liuYueZhi));     // 年支+流月地支
            set.add(map.get(monthZhi + liuYueZhi));    // 月支+流月地支
            set.add(map.get(dayZhi + liuYueZhi));      // 日支+流月地支
            set.add(map.get(hourZhi + liuYueZhi));     // 时支+流月地支
            set.add(map.get(liuYueZhi + yearZhi));     // 流月地支+年支
            set.add(map.get(liuYueZhi + monthZhi));    // 流月地支+月支
            set.add(map.get(liuYueZhi + dayZhi));      // 流月地支+日支
            set.add(map.get(liuYueZhi + hourZhi));     // 流月地支+时支
            set.add(map.get(liuYueZhi + daYunZhi));    // 流月地支+大运地支
            set.add(map.get(daYunZhi + liuYueZhi));    // 大运地支+流月地支
            set.add(map.get(liuYueZhi + liuNianZhi));  // 流月地支+流年地支
            set.add(map.get(liuNianZhi + liuYueZhi));  // 流年地支+流月地支
        }

        // 5、流日地支与其他地支留意（大运地支、流年地支、流月地支必须传入，否则结果不完整）
        if (!"".equals(liuRiZhi)) {
            set.add(map.get(yearZhi + liuRiZhi));    // 年支+流日地支
            set.add(map.get(monthZhi + liuRiZhi));   // 月支+流日地支
            set.add(map.get(dayZhi + liuRiZhi));     // 日支+流日地支
            set.add(map.get(hourZhi + liuRiZhi));    // 时支+流日地支
            set.add(map.get(liuRiZhi + yearZhi));    // 流日地支+年支
            set.add(map.get(liuRiZhi + monthZhi));   // 流日地支+月支
            set.add(map.get(liuRiZhi + dayZhi));     // 流日地支+日支
            set.add(map.get(liuRiZhi + hourZhi));    // 流日地支+时支
            set.add(map.get(liuRiZhi + daYunZhi));   // 流日地支+大运地支
            set.add(map.get(daYunZhi + liuRiZhi));   // 大运地支+流日地支
            set.add(map.get(liuRiZhi + liuNianZhi)); // 流日地支+流年地支
            set.add(map.get(liuNianZhi + liuRiZhi)); // 流年地支+流日地支
            set.add(map.get(liuRiZhi + liuYueZhi));  // 流日地支+流月地支
            set.add(map.get(liuYueZhi + liuRiZhi));  // 流月地支+流日地支

        }

        // 6、流时地支与其他地支留意（大运地支、流年地支、流月地支、流日地支必须传入，否则结果不完整）
        if (!"".equals(liuShiZhi)) {
            set.add(map.get(yearZhi + liuShiZhi));    // 年支+流时地支
            set.add(map.get(monthZhi + liuShiZhi));   // 月支+流时地支
            set.add(map.get(dayZhi + liuShiZhi));     // 日支+流时地支
            set.add(map.get(hourZhi + liuShiZhi));    // 时支+流时地支
            set.add(map.get(liuShiZhi + yearZhi));    // 流时地支+年支
            set.add(map.get(liuShiZhi + monthZhi));   // 流时地支+月支
            set.add(map.get(liuShiZhi + dayZhi));     // 流时地支+日支
            set.add(map.get(liuShiZhi + hourZhi));    // 流时地支+时支
            set.add(map.get(liuShiZhi + daYunZhi));   // 流时地支+大运地支
            set.add(map.get(daYunZhi + liuShiZhi));   // 大运地支+流时地支
            set.add(map.get(liuShiZhi + liuNianZhi)); // 流时地支+流年地支
            set.add(map.get(liuNianZhi + liuShiZhi)); // 流年地支+流时地支
            set.add(map.get(liuShiZhi + liuYueZhi));  // 流时地支+流月地支
            set.add(map.get(liuYueZhi + liuShiZhi));  // 流月地支+流时地支
            set.add(map.get(liuShiZhi + liuRiZhi));   // 流时地支+流日地支
            set.add(map.get(liuRiZhi + liuShiZhi));   // 流日地支+流时地支
        }

    }


}
